{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 查看FashionMNIST数据集的原始内容"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<PIL.Image.Image image mode=L size=28x28 at 0x29BB50F48F0>, 9)\n"
     ]
    },
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCAAcABwBAREA/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/9oACAEBAAA/APn+tbw1oNx4m8QWmkWx2yXD4LkZCADJJ+gFbviL4a63oc7COE3MW4hdn38duD976jNc9daDqllIsc9lKrMu4YGeMkdR7gj8KzcV7H8BtEvV16+1iWCeG1Wz8mOV02pIzupwCeuAp6Z98cZ90aIzLIlw0c0ZJ4KgjHoeOa+evjS9n/wnMcNxBPCYLKONFhA2FNzMpGenDcgd816V4K03wefC+m3NlpVhP+5QSXBiR5fMx825iMg5zwce3FdbOzTwgW90lu6uCm8eYrL02soIyCPQgggEdMGQ3cluiPNK0rJwrRQBNueuMkt+teNfGKxsdY8WWdxNqcNo66eieXMwVsb5DnH415Hp2rajpE5n02/urOUjBe3laMkehIPIrVm8eeLrhNknibVivoLtx/I1UPinxC3XXtUP1vJP8ay5JZJpGkldnduSzHJP41//2Q==",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACS0lEQVR4AWKgA2BkYOD1ZGBgZAHZxcjIAKZBbBBm+quS8v3rj1N/GBiZGP8wMKNIMv91cnnCzuU65+X/vww8/76hSP5iMFVgZtpp2HXm8nUz02PHGUHGQTHjf9cugd//GE7f+cUo8ft0yDSEJCMDw/8TCgyMf34x/Ph3/vYfT0VphLH/GRgY3kt+Z2fl+cH5z8aSSWwHqmsZuJiZvn18p/CPkYnr7z9ZBiaofQwMjMwMPFI/frH++sr/j537K9sldhOE5H9mhnBJJg4Gbtlf7L//cQhvusaCkGT5xXDlBxsXl6rSD2Yunr9PoraeYAGZx8T4+x/DHwaGbV+/s/1/zczxm+H3P2a9jwxMDMz///z6+Y+BwW7ime9v//z78/XrXw6GbwxsX4NAYc3AICSlJhmk/oPpN+czVjbhX1zHeOz+fWR9qcnIYNkkKvCX+cMfrl+M36+HneEVVGC4x/v5GycPHxcj83GpP3+/MTB/Z2DgF0lwy3z24/49VeFfrLxsf+UBY0xqv8vDw87Ayv/4mSiTRACHIrexMdMvJjYGRlYLlpeP+X485mHje/eQ5/uPP+svKwj9+vD77y/Wf4xsaixP/z/mFvnw5jULOysHL9Mbza+P37O/+f3nN6fERwOWC+sTn937wcPGwcb88+//by/+/WX5wfPrw4fffxRfMjIweBWLv/7wl5mNhZnxPysrGysjA+NLBrZ/EpfCGJn+MTA4tYnxMzGz/GV8+f/pvy/MDP9/f2Paff0YJBAYGBg0RN/LPPx1Fx5HFDIAaCTYdiCc4RIAAAAASUVORK5CYII=",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=28x28>"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看FashionMNIST数据集的格式\n",
    "\n",
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# 定义数据转换\n",
    "transform = transforms.Compose([]) # 创建一个空的转换组合，不对数据进行任何预处理或转换操作\n",
    "                                   # 这里使用transforms.Compose([])表示不对图像进行任何变换，保持原始格式\n",
    "                                   # 在后续代码中会加载原始格式的FashionMNIST数据，用于查看其原始数据格式\n",
    "\n",
    "# 加载FashionMNIST训练集\n",
    "train_dataset = torchvision.datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=True,  # 指定为训练集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform  # 应用数据转换\n",
    ")\n",
    "\n",
    "# 加载FashionMNIST测试集\n",
    "test_dataset = torchvision.datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=False,  # 指定为测试集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform  # 应用数据转换\n",
    ")\n",
    "\n",
    "\n",
    "# 打印训练集的第一个样本\n",
    "print(train_dataset[0])\n",
    "# 打印训练集的第一个样本的图像\n",
    "train_dataset[0][0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 加载数据集，处理为tensor格式，查看其形状"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集图像形状: (60000, 28, 28)\n",
      "训练集标签形状: (60000,)\n",
      "测试集图像形状: (10000, 28, 28)\n",
      "测试集标签形状: (10000,)\n"
     ]
    }
   ],
   "source": [
    "# 定义新的数据转换，将图像转换为张量格式\n",
    "transform_to_tensor = transforms.Compose([\n",
    "    transforms.ToTensor()  # 将PIL图像转换为PyTorch张量，并将像素值归一化到[0,1]范围\n",
    "])\n",
    "\n",
    "# 重新加载FashionMNIST训练集，应用张量转换\n",
    "train_dataset_tensor = torchvision.datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=True,     # 指定为训练集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform_to_tensor  # 应用张量转换\n",
    ")\n",
    "\n",
    "# 重新加载FashionMNIST测试集，应用张量转换\n",
    "test_dataset_tensor = torchvision.datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=False,    # 指定为测试集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform_to_tensor  # 应用张量转换\n",
    ")\n",
    "\n",
    "# 获取图像和标签\n",
    "train_images = train_dataset_tensor.data.numpy()\n",
    "train_labels = train_dataset_tensor.targets.numpy()\n",
    "test_images = test_dataset_tensor.data.numpy()\n",
    "test_labels = test_dataset_tensor.targets.numpy()\n",
    "\n",
    "# 定义类别名称\n",
    "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
    "               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "               \n",
    "\n",
    "# 打印数据集的基本信息\n",
    "print(f\"训练集图像形状: {train_images.shape}\")  # 打印训练集图像的形状\n",
    "print(f\"训练集标签形状: {train_labels.shape}\")  # 打印训练集标签的形状\n",
    "print(f\"测试集图像形状: {test_images.shape}\")   # 打印测试集图像的形状\n",
    "print(f\"测试集标签形状: {test_labels.shape}\")   # 打印测试集标签的形状\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 28, 28])\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print(train_dataset_tensor[0][0].shape)\n",
    "print(train_dataset_tensor[0][1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABb4AAAExCAYAAACzsrRmAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOc1JREFUeJzt3Qm4XVV5N/Bz55uZzCEBEwQCIgQUVFRmJ6ziwOAAzmIVJ8TGobb9tFrUilWhWi1qkaFii4oUEJRStD4Ng4gIFBEJEEMSQhIy3/ne8z3rfM/NFyJhveri5mbn93ueK+bmn7X2Pffs96z9nr33aarX6/UaAAAAAABURPOO3gAAAAAAAChJ4xsAAAAAgErR+AYAAAAAoFI0vgEAAAAAqBSNbwAAAAAAKkXjGwAAAACAStH4BgAAAACgUjS+AQAAAACoFI1vAAAAAAAqReN7lLr99ttrTU1Ntac85Sm1er3+J431lre8pTHWn5qJmjdvXu2YY44pMhYwegzXiSf6+slPfvJHj/+tb30rNMbDDz9c23333Wuf+MQnaiUtXLiwNmPGjFp/f3/RcYGRoUYBu6Lh2jT81dnZWdtrr71qb33rW2u//OUvd/TmATsJ6yiqqnVHbwCP7zvf+U6tra2ttnTp0tqNN95Ye97znrejN2mn8aMf/aj2xS9+sXbttdfu6E2BSjn11FNrhxxyyJY/n3XWWbVnPetZje8P22effZ707di8eXNt9erVtYceeiiUv+WWW2qf/exna//4j/9YmzNnzuNmBgYGapdccknttNNOa9TeNMf/+T//pzZ//vzaO9/5zsI/AfBkUKOAXdl73vOeRo3r7e2t3XfffbUrrriiduGFF9Y+9rGP1T71qU8VO8kJqCbrKKpK43uU+rd/+7fay1/+8tpVV13VaIJrfMddeumljeY3UNaLX/zixtfWi6EDDjig9oEPfGBEt2PvvfeuLVu2rDZlypRQ/oc//GHt8ssvr33hC1/Ybuaaa66prVy5snF2VLJq1apG/uMf/3ix7QaeXGoUsCs7+eSTH3PV7bnnnlt773vfWzv77LNr7e3tjSYPwPZYR1FVbnUyCt188821Bx98sPb617++9sIXvrD23e9+tzY0NLSjNwtg1EiXqbW2bv+92z/0FlEXXHBB7RnPeEZtwYIFBbYO2NWpUcCONnbs2No3v/nNxvFkOuM7nQX+eBxnAqONdRQlaXyPQukM7zFjxtT+7M/+rPHO/YoVK2o//elPt3sv7d/85jeNBc24ceNqe+65Z+38889/wvEHBwcb7+SlQpLeHduetAg655xzGu+4dXR0NN7tu/jii8M/R2rep7PWJ0yY0Chc6Z3CdOnd1tL9lT796U/X9t9//8Yc06dPr73xjW983MtaFi9e3Lg0JY2VsunffP7zn9+yWEvzpUv40iV9SYn7UAFl3XrrrbXjjz++8Q7+pEmTGrWrp6fn9xYyf//3f9+oZ7vttlvtFa94ReNeb8OG9/Wt7/uWamGqibfddlvtwAMPrLW0tNTWrVvXyP3t3/5tI5Pud5n+nO4vt7V0KV26umb4DIB0f7uUTdK/Tf9m6zOoNm7cWPvwhz/cyKQzqNIldeny4rVr1z5ujd66FqYa9773va/W3d1d9HEFylCj1CioklQf/uqv/qpxmf+//Mu/bPleqiPpsv9Zs2bVnvnMZ27Jp1pz2GGHNe4TnmrHX/7lXz7mfrh9fX2NJnq63UHKPPWpT22MM+y3v/1t7ZRTTmkcr40fP75x1XI6cxPYNVhHWUeNRm51MsqkJu5ll11We+lLX9poZL/qVa9q3HMo3frk2GOP/b182vlSYUn55zznObV//ud/buSf/exnP+b+TFtLi5/rrruu9qUvfanRXN+etMN+9atfrb32ta9tFInUJH/Tm97UKE4nnHDCE/4cGzZsaGxvuifUhz70ocZ86XK7VADSNg4XvJNOOql25ZVXNn6G1NS+//77G4un1KxOH8Yybdq0RjY199PCKS22UmM8LabSmGns1BBP25mKa7q397e//e3az3/+88b/H6n7UAF56Uyj4447rjZz5szaBz/4wcaiIi1C0mIoHTwNSwuhtPg5/fTTG/dsSzUiLVBy9+1PNSXVh7QASYuPdP+24fv9p9sf/c3f/E2jTqT6uLV//dd/bSx4hu9fl/6bPlg4Hdi95CUvadSnPfbYo/F3aVvTz/CLX/yi8cbk2972ttqdd95Z+6d/+qfaokWLajfddFPjjbnt1cLrr7++9uUvf7lxX7nhA1BgdFCj1CioonQMlerN//zP/2z53pIlS2of+chHam9/+9trEydObHwvHW+mK45T/q//+q8btSPdNzcdf/3DP/xDI5NOZPra175We/Ob31zbd999a//7v//byA0fl6b6lo5n3/WudzX++5//+Z+NWwps7767QHVYR1lHjVp1RpWf/vSn6ZqN+qWXXrrley9+8Yvr06ZNq/f39z8mO3fu3Eb2sssu2/K96667rvG9M888c8v33vzmNze+l6Rs+v/vete7HjPW1pnkpptuavz5C1/4wpbvDQwM1A888MD6oYce+oQ/w/B2ffGLX9zyvcHBwcbP0draWn/ggQca3/v2t7/dyH30ox99zL+//PLLG9//4Ac/+JjHoL29vX7HHXc8ZsxXv/rVjezW39/2ZwGeHGk/S/tb1Lnnntv4N7feeuuW7w0NDTW+kgsuuKDx9wsWLKh3d3dvyRx99NGN769atarx51RD0p8//vGP/17m05/+9O/Nm3Lp74Zrz7YOOeSQ+kknnfSY7z3eHEkaP33/a1/72mO+n+pd+v55552XrYXHH398vaWlZbvbA5ShRv1/ahRU13BtuuGGG7abmTVrVn2//fZr/P+UTV+LFi3a8vebN2+uT506tf7KV75yS81LzjjjjHpHR8eW+jZ58uT6y1/+8seMnY4RkyuuuKIx7ne/+93H/Xtg52Id9f9ZR+3c3OpkFN7mJL0blt7BGpbeaUqXZ6R3j7aV3plKfz8sXUqS/n263GJbd999d+PM7Re96EWNT7yNbMfLXvayxljpa+nSpY13z371q181bpfyRNKZ2umM8WHNzc2197///Y3L7NK7ZMNnFaR7z6Uz0LeWznJPtzG5+uqrt5w9kM7uft3rXlc76KCDHjNmOlMhGc4CO1Z6l3y4Zgx/pcvQkuEzirZ+N3/4lkRbS5eSbX1WwPCVKb/73e+y86czjP4Qt99+e+MrnWUQkepWuqztHe94x2O+/+53v7txOd+2tejxamH6c6qhN9544x+0rcCfTo1So2BXlI7B0iX7ww4++ODac5/73C1/Tsdaa9asaZwJmc4GH66P6Z646VaV6czu4Tp51113Pea2lOmWA8N/NzzW1seKw38P7Pyso6yjdkYa36NI2jnSB1lOnjy5cT+jhQsXNr62bhRvK+2U20r3FVq/fv3vff/Vr3514+/+/d///Qk/KCC55557GkVtv/32a9zbaPgrXa6RFk7pvuNPZP78+b+3yEn3gNu6oN17772N+4en+79tKzW+06Jr+F5x6Q3HtEB7vFwynAV2rFSvtq4Z6SvdVilJt016/vOf37h8Nt2KKd3W6fE+UCnVha2lujV8KdkTSQuPVD//EOkecOn+lukSt4hUt9IbcGlRs7V0MJl+1m1rUboMeNtaOHxPucjiDihLjVKjYFeTbjfw6KOPNi7t33rf3/bYb7gObl0f//zP/7zx/XQCVPK5z32ucRyYjvVSc2f4+8nRRx9dO/HEExu3tUzHkN/4xjcec39wYOdnHWUdtTNyj+9RJJ3Rne6BlgzfR21rl19+eeOealu/W/9476CnnfTxPuU2fXjAz372s9odd9xRO+qoo55wW1KBSu/YDX9Q5LbSvZOeSLrf0raGC9nwNqc5tteAT+8KDheb4WL5eNnhdw+3LUzAjpE+bCTVqsd7gyp9aO9///d/N+7Dnz449zWveU3jKpX0zvkT1bVtzxLYnvS5CH+IdDCW7vmWzgDIvRk4LFq3hm39c21bCx+vTgJPLjVKjYJdTToDO9WGrT+8bdt6NHy8dd555zWOGbc1/AGYqS6mD79MDfBvfvObja/U3EpXCaca873vfa9xT990D990xmS6L266z3fu2BHYOVhHWUftjDS+R5F0RnfaOVLzO11GsbWvfOUrtfe+972Nm/bnPljyicZPC5X0TvzNN9/8e++0bS2dEZAWSenG/sOXrPwhtr78bVhquCfpDIDhd8LSh6xs+2EHw2cdpDMJhnPJ8AenbJtLhrPAjpXeiU+3K9qetFh4wxve0PhKV7akT9JOtSl9UMlISwdm6TZSw5/wHZHqUbrEN725uPUiLX3wU/pw3m0/hDhSC4GRo0apUbArSY2fv/u7v2tcYftEtWT4bPB0NXHuWDNdxZtOxvrYxz5WO+KIIxq3s0yN72Hplp3p64ILLmh8MFw6jk0fOgfs/KyjrKN2Rk6THSXSjpTeOUtnYm/b9B6+TUna8dK9t/9YU6dOrf3gBz+odXd3NxYjw/diejzp023Tzn722Wc/5vvpNifp1iM5ixcvbnw677B0b7h0BkH62VIzPTnppJMal9595jOfecy/Tdv461//unGpTJI+FThdMnPJJZc0vr/1u3HpbIL0ZkFq5g+bMGFC47+PPPJI4FEBRsry5csfczXKK1/5ysZ/n6gWlbC9mpAOyNIncB9wwAHhf5PqVqqB6bK5raUzmtItpobrVq4Wpsv0hmshMDqoUWoUVEna59NnJP3yl7+snXvuuY1jwe15wQte0DjLMZ2lmY5Lt/2cqGHLli17TLM83QN8uEamepSOFYcNN8ee7BoKjA7WUdZRo5UzvkeJdCZ3+hDH7b3DPnv27NpznvOc2n/8x380GtfpMpI/RrpPdrrfWvrgklNOOaV2zTXXPO6lHKnRnt7BT5expQ+zTP9/06ZNjcvX3v72t9c++tGPPuE8aSGU3uV7/etf3/j/6RK49M7Z+eef3/hAyyRdcnLRRRfVPvnJT9ZuvfXWxgespHfRLr744tqhhx5a+8AHPrBlvFQ80psC6TFI7xbOmDGj9uMf/7i2aNGixgJt60vy0r9NUi5td/pZ0iU5wI6V9v+0MEgfsJvOPEqXwaX/vvSlL31S5x2uCelelGkBlt5IS5fkpfqXasvjSQeHc+fObbzhlu47ly7RPfPMM2sf/vCHG5/FkOpgqtuptqSrUdJnJ6Q3FLddDM2ZM6dRb0877bTH1MJ0afAfW8eBJ4capUbBzizt++lD3NLVtOk+tVdccUXjkvvU9E5nXj+RdA/cD33oQ40TklJNSrUoXcKfrgBOdTDVo+GrbNMxZDqT8YEHHmicUTl8H/Af/vCHtc9+9rONs7/TWaFp/nScufUJSkB1WUdZR41adUaF0047Lb01Vl+8ePF2M5/73Ocamcsuu6zx57lz59aPPvro38tt+/03v/nNjX+3tYULFza+9653vWu7mfXr19ff+9731mfNmlXv7Oysz58/v/6BD3ygvnLlyif8WYbnv/baa+sHHHBAvb29vfHfCy+88PeymzZtqn/4wx+uP+UpT6m3tbXV99xzz/pZZ53VmHtbv/rVr+onnHBCfeLEiY3tOeyww+qXXnrp7+X6+vrqb3nLWxq56dOn12+//fYn3F7gj5NqRqodUf/1X/9Vf/azn10fN25cferUqfXjjz++fvPNN2/5+wsuuKAx5g033PCYf7ft9x944IHGnz/+8Y9vyaSak2rP9qQ6k+acNGlS/Zprrql//vOfr3d0dNTXrl273X+T5ttvv/0aube+9a1bvr9q1ar6O9/5zkZtTHVrn332qX/yk5+s9/b2Pm4tvPrqq+tPe9rTttTCiy++OPyYAX88NUqNgl3BcA0a/krHSWm/T8d599xzT7g2Dg0N1b/whS80jvlSPUjHZaecckr9jjvu2JI5/fTT67Nnz27UnTTHJz7xiS21JR2rHXPMMY1jsFTLjjzyyMbxILBzso6yjqqKpvQ/O7r5DgAjKX1a99Of/vQ/6fZROek+menrJz/5yZM2B1BNahQAwB/HOoqtucc3ALuUdGuldAlaut0SwGijRgEA/HGso9iWe3wDsEs57LDDHvPBKwCjiRoFAPDHsY5iW874BgAAAACgUtzjGwAAAACASnHGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKa3RYFNT05O7JcBOabR8TMDOXKMi2z5aHudt7b///tnMl7/85dBYl112WTbzy1/+Mpvp6+sLzdff35/NHHjggaGxXv3qV2czixcvzmbOOeec0Hzr1q0L5Rg9+87OXKNGqxkzZmQzb3nLW7KZiy66KDTfww8/XNtZHXLIIUXq+fe+971i9ZX/R43a+cybNy+UO+aYY7KZV77yldnMmjVrQvNdcskl2cxtt91WpBYkJ510Ujbzghe8IDRWV1dXkZ/v/PPPD81HnBoFtdrs2bOzmeXLl4/ItvCH1yhnfAMAAAAAUCka3wAAAAAAVIrGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKRrfAAAAAABUisY3AAAAAACVovENAAAAAEClNNXr9Xoo2NT05G8NsNMJlpAn3UjXqOh8I/34HHLIIdnM6173utBYJ510UjYzODiYzYwbNy4035gxY7KZqVOn1kaje++9N5sZGhrKZvbbb7/QfCtXrsxmfvSjH4XG+vznP5/N3HXXXbWd1a5ao3Zm48ePD+UitezMM8/MZvr6+kLzrV69ushY0fkmTJiQzXR0dITG2mOPPbKZK664Ipu58cYbQ/NddtlloRxq1Eh56UtfGsqdddZZ2Ux3d3dorPb29mymp6enSC1IDjzwwGxm5syZ2cyDDz4Ymm9gYCCbWbFiRWis9evXF6l3c+bMCc13/fXXZzPvf//7Q2NVnRq184k8v5PJkydnM2vWrMlm3vGOd4Tmi9aWUmbPnp3N3HDDDcWOU5csWZLNHH/88aH5Nm/eHMpRC9UoZ3wDAAAAAFApGt8AAAAAAFSKxjcAAAAAAJWi8Q0AAAAAQKVofAMAAAAAUCka3wAAAAAAVIrGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKU31er0eCjY1PflbA+x0giXkSbcz16iJEydmMxdddFForAULFmQzzc2x9zw3btyYzfT09GQz/f39ofkGBwezmba2tmxm0qRJofk2b96czQwNDY3K/aCzszObGTNmTGis9vb2bOZnP/tZNvPGN76xNhqpUdV1yimnZDPd3d3ZzF/91V+F5ps9e3Y2M3PmzGymo6MjNN/atWuzmU2bNoXGuu6667KZSy+9NJsZP358aL4f/OAHoRxqVAl77713NvOJT3wiNNbKlSuzmbFjx4bGiqy3IuuMgYGB0Hx77rlnrYTo2ieSW79+fWisyM8YWU8++uijofnmzJmTzaxbty401sKFC2tVpkbtfH7yk58Uq52RNUv0mCNybPm9730vm3nDG94Qmq+lpaXIsWy0HkTWnAcffHBoPsrWKGd8AwAAAABQKRrfAAAAAABUisY3AAAAAACVovENAAAAAEClaHwDAAAAAFApGt8AAAAAAFSKxjcAAAAAAJWi8Q0AAAAAQKW07ugNYOQ0NTVlM/V6vdh8EyZMyGaOOOKI0FjXXHPNiD0GSUtLSzYzMDBQG42iP2NEyecD2/f9738/m5k7d25orEceeSSbGRoaCo3V2tpaZD+IPicj80XGWr16dbH9PKq5eWTfR+7u7s5menp6iu3nRx11VDaz//77h+a75557QjnIaW9vz2bWrVuXzXz5y18Ozff+978/m+nt7c1mOjo6QvNFtv0Xv/hFaKwLLrggm9lrr72ymVWrVoXmg5H0F3/xFyP63I2+5nd2dhZZR0WPOR544IFsZv369UW2O7qejNa7iMHBwSJryWTJkiXZzIEHHhga62Uve1k2c/XVV4fGghLWrFkTykVe9yNjTZkyJTTfrFmzspn3ve992czBBx8cmm/BggXZzNq1a0NjRWpL9HFn5DnjGwAAAACAStH4BgAAAACgUjS+AQAAAACoFI1vAAAAAAAqReMbAAAAAIBK0fgGAAAAAKBSNL4BAAAAAKgUjW8AAAAAACpF4xsAAAAAgEpp3dEbwMhpbs6/zzE4OJjN7LPPPqH5Tj/99Gymu7s7NNbmzZuzmZ6enmzmlltuCc03MDBQK6WpqanI7yYyTultb2lpKTbWrurQQw/NZubOnZvNrF69OjRfa2trsd9rZ2dnNjNnzpxsZuzYsaH5IvtBf39/kccgWu+i+11bW1uRfXPjxo2h+R566KEi80VFHqtIzU8WLlxYYIugVtu0aVM2M23atGxmyZIlofk++MEPZjN77LFHNjN9+vTQfA888EA2s2bNmtBYkcchUjujNRFG0re+9a1s5qyzzgqNtWrVqmxm5cqVobEmTJhQZF0T1dfXV6QWRG3YsKHYsd5IPgbJpEmTspmlS5eGxrr66qtDORgp999/fyh3+OGHFzme6O3tDc1Xag3x4IMPhnJHHnlkNrNs2bLQWGPGjCl2zMvIc8Y3AAAAAACVovENAAAAAEClaHwDAAAAAFApGt8AAAAAAFSKxjcAAAAAAJWi8Q0AAAAAQKVofAMAAAAAUCka3wAAAAAAVErrjt4ARk5LS0s2Mzg4mM0cd9xxofle+MIXZjMPPfRQaKyOjo5sZuzYsdnMi170otB83/jGN7KZlStXhsaq1+tFHveo8ePHZzNDQ0Ohsbq6ugps0a7t2GOPLfL8jmSiv9tILUh6e3uzmY985CPZzPLly0PzRerB7Nmzs5kVK1aE5mtuzr/329fXFxor8vuJ7JvPfOYzQ/O9733vy2ZWr14dGqu1tbXI8+rkk08Ozbdw4cJQDnIGBgaKjDNt2rRaKZH97uGHHw6NFVnXzJkzJzRWZJ0RWa9EMjDSbrnllmzmxhtvDI31ile8Ipu5+eabi72+RvbzNWvWhOaLrFkiNaqnpyc0X2TbI49BsmHDhmxm+vTptVIi2/7Rj3602Hwwku6+++5QLnpMmLN58+ZiNWrBggW1Urq7u7OZpqam0FiRWhapY+wYzvgGAAAAAKBSNL4BAAAAAKgUjW8AAAAAACpF4xsAAAAAgErR+AYAAAAAoFI0vgEAAAAAqBSNbwAAAAAAKkXjGwAAAACASmnd0RvAyOnr6ysyzrOe9axQbt68edlMS0tLaKzm5vx7ND/60Y+ymWc84xmh+T73uc9lM7feemtorDvvvDOb+fWvf53NPPvZzy72+1m0aFForBtvvDGUY/tOPvnkbGZgYKDYvjI4OJjNdHZ2hsZav359NvP1r389m3nxi18cmu+Zz3xmNnPBBRdkM+985ztD8911113ZzJQpU0JjRX4/K1euzGa++MUvhuZ797vfnc20tsZe4iPPh66urmxm//33D803f/78bObee+8NjcWuLbI2qNfrRepmdD/fbbfdaqNRU1NTkccqWldgtDnvvPNCuTPPPDOb+d3vfhcaa9WqVdnM5s2bi7wGJxs3bqyVEF1zRrY9WjPa2tqK/HyTJk0KzXfNNddkMxs2bAiNBaPNsmXLQrn+/v4ia63I/pusWLEim7ntttuK1brI4xCtd5F1VOTYmR3DGd8AAAAAAFSKxjcAAAAAAJWi8Q0AAAAAQKVofAMAAAAAUCka3wAAAAAAVIrGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKRrfAAAAAABUSuuO3gD+dE1NTaFcvV7PZl70ohdlM4cddlhovo0bN2Yz48aNC401f/78Ipmf//znofnuu+++bGb8+PGhsZ773OdmMyeeeGI209/fH5ov8jOefvrpobF6e3tDObbv4IMPzmaWLl2azTQ3x96n7OjoqJUyceLEIuNce+21odzmzZuzmQMOOCCbWbhwYWi+yy+/PJs54YQTQmO1tuZfTm+77bZs5tBDDw3NNzAwUKy+Dg4OZjNDQ0PZzO9+97tiNfHee+8NjcWuLfI6HKmJPT09oflaWlqK7CuRcf6Q9V1E5DUkkuns7Cy0RVBO5DU48rqZHHHEEdnM2WefXSulq6ur2LaPGTMmm+nu7i7yeEZz0WOJ6Dq31DhXXnllkflgNFq+fHkoF+kvRNYikbVPdL119913ZzNtbW3F6sH69etDY0XWkyXXbZTljG8AAAAAACpF4xsAAAAAgErR+AYAAAAAoFI0vgEAAAAAqBSNbwAAAAAAKkXjGwAAAACAStH4BgAAAACgUjS+AQAAAAColNYdvQG7sqamptpo86lPfSqb2X333YvNN3bs2FBuYGAgm+nr68tmjjjiiNB8hx12WDYzNDQUGuu2227LZu67774ij0Hynve8J5t56lOfGhrr5JNPDuV2RQceeGAot2rVqiK/25aWlmJ1ZcyYMaGx1qxZUxvJx6q3t7dI/Tn77LOLPVb9/f3Fxnruc59bK2X58uXZzJw5c0JjDQ4OFql33d3dofmOPPLIbObCCy8MjcWurbW1tci+GV2PNTc375TzRV9nIvNFX4tgJEXXyBErVqzIZhYvXhwaa6+99spmenp6spmNGzeG5ou8Vkfmi9SCZNOmTdnM9OnTR7RGLVmyJDQfVNnq1atDuXnz5mUz99xzT5G6El2zRNZ2UZH+UHQdFTleih43MvKc8Q0AAAAAQKVofAMAAAAAUCka3wAAAAAAVIrGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKRrfAAAAAABUisY3AAAAAACVovENAAAAAECltO7oDdiV1ev12mizdu3abGb33XcPjdXd3Z3NdHR0hMZqbc0/VcePH5/N9PT0hOYbM2ZMNjM0NBQa68gjj8xmnve852Uzzc2x96lmzJiRzVx77bWhsdi+j3zkI8WeS5s2bcpmBgcHi80X3Q8GBgaymcMOOyybmTp1ami+KVOmZDNtbW3ZzMyZM0Pz9ff3F3us2tvbs5nddtstm3nta18bmm/y5MlFanAyadKkImNFHoPocwYiIq+LXV1d2UxLS0ux+ZqamorV85FeS/b29hYbC6osuiafMGFCkeOJ6PHShg0birxWR9c+fX19tVIia86IRx55pMg4sDN7+OGHR7TeRY7PomOVXPtEtityPBjtR0V6aewYzvgGAAAAAKBSNL4BAAAAAKgUjW8AAAAAACpF4xsAAAAAgErR+AYAAAAAoFI0vgEAAAAAqBSNbwAAAAAAKkXjGwAAAACASmnd0RvA6DJ27Nhsprk59n5JJNfV1RUaa/369dnMmjVrspl58+aF5qvX69lMU1NTscch8rgPDg6G5hsaGspm9txzz9BYbN+iRYtCuVmzZmUz++yzTzYzceLE0Hzjxo3LZn7729+Gxoo852666aYiz8loLrJNLS0toflaW1uL7eeR7YrUgo0bN4bmu/fee4vUlejjFdn25cuXh+b7wQ9+EMpBqfVIqZoRqVGl9qfSIvWut7c3m5kxY0ahLYKRFd3vIvv5Qw89FBprwYIFRbYrsm9Gj1/a2tqKHXN0dnZmM93d3aGxenp6splp06ZlM8uWLauNZN1MBgYGis0JIylaW0rUnpJjRY8tI7UsWu8ix4QbNmwIjcXIc8Y3AAAAAACVovENAAAAAEClaHwDAAAAAFApGt8AAAAAAFSKxjcAAAAAAJWi8Q0AAAAAQKVofAMAAAAAUCka3wAAAAAAVErrjt6AXVlTU1M209ycf29icHAwNN/48eOzmdmzZ2czvb29ofkiuY6OjtBYfX192UxXV1c2s9tuu4XmW7NmTTYzduzY0Fjt7e3ZzMaNG7OZSZMmhea74447ijwXksMOOyyU2xV99atfLZabPHlyNrPvvvuG5jvjjDOymaOPPjo01qOPPprN3HXXXdnMunXrQvO1tbVlMy0tLbUq1/Oenp7QfJF6EKkFyWmnnRbKwUiJ1MRoPYjsm/V6PTRfZB8eaUNDQ6Fca2trkfozbty40HydnZ1F5oPR6MEHHyxWMyLHCdGaGNmugYGBbGbq1Kmh+dauXVtkvuhxY+TxjM4HxNcQpUTWW5F1WyQTFR0rsu2bN28usEU8GUbfCh4AAAAAAP4EGt8AAAAAAFSKxjcAAAAAAJWi8Q0AAAAAQKVofAMAAAAAUCka3wAAAAAAVIrGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKa07egN2ZfV6PZtpaWnJZgYHB0Pzvfa1r81mZs2alc2sWrUqNN+YMWOymaGhodBY48aNy2b23HPPbKavry80X0dHRzbT398fGqu1tbXIYzV16tTQfF/5yleymUMOOaTYtvOnW7t2bTZzyy23hMbq7e3NZo477rhiNaq9vb3I/hutd9GaEdHU1FQkE92uSF2J1qjOzs5sZtGiRaGxYLSJ1LFoLlLHSio5X6T+NDeXO4clUoPXr18fGqunp6fAFsHo1N3dHcqVWrNEx4nsw5H1Q3S+yPp12rRpobEmTJhQK6Gtra3IOLArKLmGKLWuidSxkj9fdN0W6bnNmDEjNBYjzxnfAAAAAABUisY3AAAAAACVovENAAAAAEClaHwDAAAAAFApGt8AAAAAAFSKxjcAAAAAAJWi8Q0AAAAAQKVofAMAAAAAUCmtO3oDdmWtrfmHv6+vr9h8d911VzbT29ubzbS1tYXma2lpyWYGBwdDY82YMSOb6enpyWbWrFkTmi/yM3Z2dobGGjduXDazdu3abOahhx4KzXfqqadmM+ecc05orJtuuimUY/uampqKPN+itaBer2czGzZsGNF9OLJNJR/PkvONtMhjHrVu3boR3a6hoaHQWDvz74eREX2OlNxfqi7ymHZ0dIzItsCOEH2NihgYGAjlVq1aVWR9FzlOiIqMFV1zjhkzJpt55JFHQmNNnz49m9m0aVNoLKDccVXJcSK55ubmYjU4Ml+kJxedc968eaGxGHnO+AYAAAAAoFI0vgEAAAAAqBSNbwAAAAAAKkXjGwAAAACAStH4BgAAAACgUjS+AQAAAACoFI1vAAAAAAAqReMbAAAAAIBKad0RkzY1NWUzLS0tobGam5uLzNff3x+ab2hoqFbKwMBAbST98Ic/zGY2b96czXR3d4fma29vz2bq9XporFWrVhV5znR2dobmiz4fSo0VeV5F94kFCxZkM+vXrw+NxZ8u8hwv+XxbvHhxNrNhw4bQWK2t+ZeIvr6+2kg+VpF6Hq0rEZH5oiKPVVtbW7H5or/nUq+1g4ODxeZj1xZ9vYuIvL5Gnt8lRdeSI71dJffzyFgl19RQan+KPC8nTJgQGmvy5MnZTFdXVzYzZcqUWimrV6/OZsaOHRsaa9KkSSO6ToysyebOnbvTHqvDSCt1nBOtr6XmK3l8Fl1zRtY/8+bNK7BFPBmc8Q0AAAAAQKVofAMAAAAAUCka3wAAAAAAVIrGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKRrfAAAAAABUisY3AAAAAACVovENAAAAAECltJYcrKWlJZQbHBzMZgYGBmpVd9RRR2UzJ510Ujbz/Oc/PzRfV1dXNrNmzZpspr29PTRfa2trkedCdNsjz7+Ojo7QfJ2dndlMvV4vtu0R0cd906ZN2cyJJ54YGuvKK68M5fjTNDc3F9tXuru7s5m+vr7QWJH9JVKrI7UgaWpqKrLfRcaJ5iK/m+h29fb2ZjNjx44ttu27wuso1RR5DY7udyVrRqQOR2pGdL1cUqn6Gl37RNYsPT09obGghKGhoWJjrVq1KpS76667spmlS5cWWxtE9qmZM2cWWyc++OCDRbYpmTRpUjazYsWKbGb27Nmh+aDK5s+fX+y1OlI7o8d6EZF1VMljvehYkeOqadOmhcZi5DnjGwAAAACAStH4BgAAAACgUjS+AQAAAACoFI1vAAAAAAAqReMbAAAAAIBK0fgGAAAAAKBSNL4BAAAAAKgUjW8AAAAAACqlteRgg4ODtZE2ZcqUbGb27NnZzL777huaLzLWiSeeGBpr/vz52Uxvb28209wce/+iq6srm5k6dWo2s3z58tB8PT092Ux7e3torBkzZmQzfX192czYsWND8y1atCibGT9+fGiso446KpsZGhrKZtavXx+ar7+/P5s5/PDDQ2MxMur1erGxIs+laK2ObFckE61RpX6+lpaWYvM1NTWFcpGfMfJYRX6+kvNFlRwLSu13kVwkU/L5Hd320ajktpes+zDaHHnkkaHc/fffn80sWbKkyDFVsmHDhmxm4sSJ2cykSZNC83V3dxc5Pkt23333WgmzZs0qdmz5yCOPFKt30fUdlPC0pz0tlHvooYeK9Bba2tpqpUSO43bEeiXSl5s5c2Y287znPa9YP4o4q1IAAAAAACpF4xsAAAAAgErR+AYAAAAAoFI0vgEAAAAAqBSNbwAAAAAAKkXjGwAAAACAStH4BgAAAACgUjS+AQAAAACoFI1vAAAAAAAqpbXkYIcffngo96lPfSqbmT59emis3XbbLZsZHBzMZlpaWkLzrVu3LpsZGBgIjbVx48Zspq+vL5tpamoKzdfd3Z3NLFq0KJt5zWteE5rv1ltvzWYmTJgQGqu3tzebmTdvXq2Ugw46qNi2L126NJvp6urKZsaMGROab/z48dnM3LlzQ2NRTXPmzAnl1q5dW6R21uv10HzNzc3F6t1oFPn5+vv7Q2NFHofo6xqMNjvzczdS70rWsehYke2KPO7R301ra9FDDPiTX1+HhoZCY+25557ZzAEHHBAa6/777y9yLDtt2rTQfPfdd182M27cuGxmr732KnZcPHHixNpI2rRpUyh36qmnZjNf+tKXQmNFn1swUl7wghcUWxuUPD6LHhOO1Dh/yLomMufixYuzmTPOOCM0X6QvR5wzvgEAAAAAqBSNbwAAAAAAKkXjGwAAAACAStH4BgAAAACgUjS+AQAAAACoFI1vAAAAAAAqReMbAAAAAIBK0fgGAAAAAKBSWqPBlpaWbOa8884LjbX77rtnM4ODg6GxIrmurq5aKe3t7cW2vbu7u8AW1WqTJk0K5ebOnZvNfPazny223WeccUY2s3z58tBYPT092cz111+fzdx///2h+fbdd99sZurUqaGx+vr6spm2trZsprk59j5Vf39/NrNq1arQWIyMer0+ovMNDAyMyprY1NQ0Ypno4x4da2hoqMh+3tvbW2zbI/ON1ucou7bofhepLSX38+jr8EjuT9GxSm179LGKrE03bNhQYIsg9hoc9ZKXvCSbufvuu0NjdXZ2FtkP5s2bF5pv2bJl2cz+++9f7PF86KGHspkFCxaExlq5cmWRY6+1a9eG5pszZ042s88++4TGuu+++0I5GCmHH354sb5BpA9Y8tirtTXcoiwiuj6K1PNIz+q5z31uaD7KcsY3AAAAAACVovENAAAAAEClaHwDAAAAAFApGt8AAAAAAFSKxjcAAAAAAJWi8Q0AAAAAQKVofAMAAAAAUCka3wAAAAAAVEprNPimN70pm5k7d25orMWLF2cz48ePD40VyU2ZMqVWSltbWzYzadKk0FhLly7NZpYvX57NjB07NjTfypUrs5kLL7wwm3nVq14Vmu/KK6/MZubNm1fs93zooYdmM8cee2xovubm/HtCfX19obE6Ojqymfb29lopg4ODRZ7HyZ577llgixhtent7Q7mWlpZsZmBgoMg4ydDQUDZTr9eLzRfZhyPzJa2trUXG6urqqpWy2267FRsLRlL0NSryWt3U1FRgi+JjRWvGaBRZP0R/vsjaB0ajBQsWZDN33HFHaKzIeiRyDFByf4qukUqt2yKZpKenp8hxyYYNG0LzRXLR49T77rsvlIOREn3url27tshaq+TaJ1KjdsRaK7Jdkb7crFmzQvNF6n70mB5nfAMAAAAAUDEa3wAAAAAAVIrGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKRrfAAAAAABUisY3AAAAAACVovENAAAAAEClaHwDAAAAAFAprdHgI488ks0sXbo0NNaECROymd7e3tBYkTnHjx+fzbS3t4fmmzhxYjbz6KOPhsZasmRJkW3v7u4OzdfT05PNDAwMZDOXX355aL4777wzm5k3b15orClTpmQzfX192cy6detC8/X39xd5rJKhoaFspq2trcg4SVNTU7Hn+/z580M5di7R51IpkedkUq/Xi8zX3NxcdLtKbXtkvuhjEKk/Y8aMqZVS6ncDEa2tseVpZJ9qaWnJZnaF53d0zVJiffSH1GEYKdFjjhUrVmQznZ2dobE2bdpUpN5F999Sr/slj3E6OjpqpXR1dWUzM2fODI21bNmybGb69OmhsWAkTZ48OZuZNm1aaKyVK1cWqXfRdVSpY6HBwcFia5Ho8WCkf/LjH/84mznllFNC8x166KHZzKJFi0Jj4YxvAAAAAAAqRuMbAAAAAIBK0fgGAAAAAKBSNL4BAAAAAKgUjW8AAAAAACpF4xsAAAAAgErR+AYAAAAAoFI0vgEAAAAAqJTWaHDZsmXZTL1eD4310EMPZTPjxo0LjTVt2rRsZt26ddnM6tWrQ/OtWrUqm2ltjT2sHR0d2UxbW1s209nZGZpvwoQJ2Uxzc3Oxx+ppT3taNrN58+bQWEuXLs1m1q5dW+Qxj/6M/f39obEGBgaKjDVmzJjQfLNmzcpm1q9fHxrrkEMOCeXYuUT285Kirw0j/fM1NTWN6M8Y2a7oYxWpK2PHjg2NBaNNe3t7sbEi+9TQ0NCorJ0jLfJYRdc+6g+jzVOe8pRQLlIPosd6kVoWOY4bHBwMzRfdrpzJkycXW4tEtymSe+CBB7KZfffdNzTfypUrs5lJkyaFxpoyZUo28+ijj4bGghLH59FjnEhtiYwVPX6JrKMiNTG6TozU85LHXvvtt1+xmhjppS1atCg0Fs74BgAAAACgYjS+AQAAAACoFI1vAAAAAAAqReMbAAAAAIBK0fgGAAAAAKBSNL4BAAAAAKgUjW8AAAAAACpF4xsAAAAAgErR+AYAAAAAoFJao8Hbb789m/n+978fGuttb3tbNrN8+fLQWPfff38209PTk82MHz8+NF9bW1s2M2bMmNBY7e3t2UxLS0s209vbG5pvcHAwm6nX69lMV1dXaL4VK1YUmS+67a2trUWeC9HnQ19fX2isdevWFcn09/eH5hsYGMhm9tprr9BYK1euDOX400T3g5EWqT8j/Tg0NTWNyp+v1O+wubm5WE0c6d8flBJZH0X3u8hrYsm6MlpFakukrkTXIvvss082Ezm2gFKir4mRfSV6LDR27Ngix5bRY46hoaEidTN6XBypr9Hj1Dlz5mQzt956azZz1FFHFTtOjRxbJpMnT85mHn300dBYkHPCCSdkM6tXrw6NFXlNj9SVSCZaWyJrskjdTDo7O7OZDRs2FHusZs2aVaRuJgcddFAoR4wzvgEAAAAAqBSNbwAAAAAAKkXjGwAAAACAStH4BgAAAACgUjS+AQAAAACoFI1vAAAAAAAqReMbAAAAAIBK0fgGAAAAAKBSWksO9pnPfCaUu/3227OZhQsXhsaaN29eNrN69epsZt26daH5Nm/enM20tLSExmpvb89mWltbi83X1NSUzdTr9Wymra0tNF8kF3kMomNFfr6oyFgrV64MjTV+/PhsZsqUKdnM0NBQaL5Zs2ZlM3fccUdorEsuuSSbufjii0Nj8eTvm1F9fX2h3NixY2sjKfIcj9S7gYGBUfm4lzQ4OFjstSFitD4OVNPs2bOLjdXc3Fzs+V2qRpXcnyI/X3TbIzUxWl8ja28YSdOmTQvlIscmq1atCo114IEHZjOdnZ3ZzIYNG4pte2QfnjBhQrH5enp6QmMtWLAgm7n66quLHdNHtn3y5MmhsSLH61DK3nvvXWwfjvQNIuuMRx99tNh8J5xwQjZz1VVXhebr7u4udry7cePGWgnjxo0L5Z7+9KcXmY//xxnfAAAAAABUisY3AAAAAACVovENAAAAAEClaHwDAAAAAFApGt8AAAAAAFSKxjcAAAAAAJWi8Q0AAAAAQKVofAMAAAAAUCmt0WBzc75HPjQ0FBrrmmuuKZJJjj322GzmM5/5TDYzd+7c0HyTJk0q8lglLS0t2Uxra/5XNDg4WCvlkUceyWbq9XporGXLlmUzvb29obE2bdpU5PGMivyM/f39obG6urqKPGeuu+660Hy//vWvs5lFixaFxmLXFnleRupPU1NTsflKZaKvWdFtL1VXotseUbImwkjq6ekJ5dra2orsd9F9JVIPIjWx5L4ZXYtE5ozUxPHjx4fmW7JkSSgHI2XatGmhXOR1eM2aNcWOGyPHeitWrAjN197ens2sXbs2m9m8eXNovpJrllLHg5GfL1rvoo/D7rvvns385je/CY0FOVdddVU2c8wxxxSbL7KvjBkzZkT386iBgYFspq+vr9h8kTVgdI175513FtgihjnjGwAAAACAStH4BgAAAACgUjS+AQAAAACoFI1vAAAAAAAqReMbAAAAAIBK0fgGAAAAAKBSNL4BAAAAAKgUjW8AAAAAACpF4xsAAAAAgEppjQaHhoZqo9ENN9yQzRx++OHF5tt///2zmWnTpoXGWrduXTazxx57ZDMPPvhgaL7+/v5sZvHixaGxgHLq9fqIzrd8+fJQbv78+dnMwMBAsdePSK6trW1E54v+bgYHB7OZ1tbwS26R7WppaRnR+aCUW265pViN2m233bKZ7u7uWilNTU1F6uaO2O923333IrUuuffeewtsEZQzfvz4UK6rqyubmTx5cq2Uzs7ObKavry80VmSdMX369Gxm1apVofnGjRtXZL7o8fPee+9dbA3Y3NxcbKwJEyaEclDC17/+9Wzm/PPPL7ZmWb169Yj2CkuOFdn2SZMmFeulRWrBxIkTQ/Ode+65oRwxzvgGAAAAAKBSNL4BAAAAAKgUjW8AAAAAACpF4xsAAAAAgErR+AYAAAAAoFI0vgEAAAAAqBSNbwAAAAAAKkXjGwAAAACASmnd0Ruws7nnnntGdL677rprROcDqm+33XYL5caNG5fNtLbmX0amTZsWmq+5ublIpq2trTbSBgcHs5mWlpZsZunSpaH5xo4dm83svffetVIij/vQ0FCx+di1dXV1hXIXXXRRNnPssccWq1GRmhjZzwcGBmojuW9Ga9QDDzyQzdxwww1Ff4cwUvbdd99QLrIfdHZ21kZyH4685ic9PT3ZzKJFi7KZU089NTRfZA14/fXXj+gaMLrG3bx5c5Hnwh9SF2GkHHTQQaHcnXfeWWS+3t7eWikzZswoNtbMmTOzmTFjxhSrdxMmTMhmXvKSl4TmW7JkSShHjDO+AQAAAACoFI1vAAAAAAAqReMbAAAAAIBK0fgGAAAAAKBSNL4BAAAAAKgUjW8AAAAAACpF4xsAAAAAgErR+AYAAAAAoFI0vgEAAAAAqJSmer1eDwWbmp78rQF2OsES8qTbmWtUZNtLPs7nnHNOKNfR0ZHNrFu3Lptpa2urldLcnH+/dtOmTaGxIo9p9Hk1MDCQzQwNDWUzfX19ofkmT56czdxyyy2hsa666qpalalRO5/oYzXSv9spU6ZkM7NmzcpmJk6cWGiLarWHH364WK6np6e2s76u7cxGy+NQ9RrV2tpa7PU8shaJvu7vvffe2cySJUtC8+2xxx7ZzIMPPhgaC4apUbu2I444Ips54IADQmMdd9xx2cxZZ52VzaxYsaLYMe+MGTNCY33nO9/JZq655prQWIx8jXLGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKRrfAAAAAABUisY3AAAAAACVovENAAAAAEClaHwDAAAAAFApGt8AAAAAAFRKU71er+/ojQAAAAAAgFKc8Q0AAAAAQKVofAMAAAAAUCka3wAAAAAAVIrGNwAAAAAAlaLxDQAAAABApWh8AwAAAABQKRrfAAAAAABUisY3AAAAAACVovENAAAAAECtSv4vYfWSXd31DD4AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1500x300 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入matplotlib用于绘图\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.font_manager as fm\n",
    "from matplotlib import rcParams\n",
    "\n",
    "# 设置中文字体显示\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']  # 使用黑体显示中文\n",
    "plt.rcParams['axes.unicode_minus'] = False    # 正确显示负号\n",
    "\n",
    "# 创建一个图形，包含5个子图\n",
    "plt.figure(figsize=(15, 3))  # 设置图形的大小\n",
    "\n",
    "# 显示前5张图像\n",
    "for i in range(5):\n",
    "    plt.subplot(1, 5, i+1)  # 创建1行5列的子图布局\n",
    "    plt.imshow(train_images[i], cmap='gray')  # 以灰度模式显示图像\n",
    "    plt.title(f\"{class_names[train_labels[i]]}\")  # 添加标题为类别名称\n",
    "    plt.axis('off')  # 关闭坐标轴显示\n",
    "\n",
    "plt.tight_layout()  # 自动调整子图参数，使之填充整个图像区域\n",
    "plt.show()  # 显示图形\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 把数据集划分为训练集55000，验证集5000，测试集10000，并给DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集大小: 55000\n",
      "验证集大小: 5000\n",
      "测试集大小: 10000\n",
      "批次大小: 64\n",
      "训练批次数: 860\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 从训练集中划分出验证集\n",
    "train_size = 55000  # 定义训练集的大小为55000个样本\n",
    "val_size = 5000  # 定义验证集的大小为5000个样本\n",
    "# 设置随机种子以确保每次得到相同的随机划分结果\n",
    "generator = torch.Generator().manual_seed(42)  # 创建一个随机数生成器并设置种子为42\n",
    "train_subset, val_subset = torch.utils.data.random_split(\n",
    "    train_dataset_tensor,  # 要分割的原始训练数据集，60000个样本\n",
    "    [train_size, val_size],  # 分割的大小列表，55000个训练样本和5000个验证样本\n",
    "    generator=generator  # 使用之前创建的随机数生成器，确保每次得到相同的随机划分结果\n",
    ")\n",
    "\n",
    "# 创建数据加载器\n",
    "batch_size = 64  # 设置批次大小为64\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    train_subset,  # 使用训练子集创建数据加载器\n",
    "    batch_size=batch_size,  # 设置批次大小\n",
    "    shuffle=True  # 打乱数据集，每次迭代时，数据集的顺序都会被打乱\n",
    ")\n",
    "\n",
    "val_loader = torch.utils.data.DataLoader(\n",
    "    val_subset,  # 使用验证子集创建数据加载器\n",
    "    batch_size=batch_size,  # 设置批次大小\n",
    "    shuffle=False  # 不打乱验证集数据顺序\n",
    ")\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    test_dataset_tensor,  # 使用测试集创建数据加载器，10000个样本\n",
    "    batch_size=batch_size,  # 设置批次大小\n",
    "    shuffle=False  # 不打乱测试集数据顺序\n",
    ")\n",
    "\n",
    "# 打印数据集大小信息\n",
    "print(f\"训练集大小: {len(train_subset)}\")  # 打印训练集的样本数量\n",
    "print(f\"验证集大小: {len(val_subset)}\")  # 打印验证集的样本数量\n",
    "print(f\"测试集大小: {len(test_dataset)}\")  # 打印测试集的样本数量\n",
    "print(f\"批次大小: {batch_size}\")  # 打印每个批次的大小\n",
    "print(f\"训练批次数: {len(train_loader)}\")  # 打印训练过程中的批次总数\n",
    "\n",
    "# DataLoader的作用和优势解释\n",
    "\n",
    "# DataLoader是PyTorch中用于加载数据的工具，它提供了以下几个关键功能：\n",
    "\n",
    "# 1. 批次处理（Batching）\n",
    "#    - 将数据集分割成大小相等的批次（batch）  # 批次处理使模型训练更高效\n",
    "#    - 每次迭代返回一个批次的数据，而不是单个样本  # 批量处理数据可以加速训练过程\n",
    "\n",
    "# 2. 数据打乱（Shuffling）\n",
    "#    - 通过shuffle=True参数启用  # 设置是否在每个epoch打乱数据\n",
    "#    - 有助于模型泛化，防止模型记住数据顺序  # 打乱数据可以提高模型的泛化能力\n",
    "\n",
    "# 3. 并行加载（Parallel loading）\n",
    "#    - 通过num_workers参数控制  # 设置数据加载的工作进程数\n",
    "#    - 使用多个CPU核心同时加载数据，提高效率  # 并行加载可以减少数据准备时间\n",
    "\n",
    "# 4. 内存优化\n",
    "#    - 只在需要时加载数据，而不是一次性加载整个数据集  # 按需加载数据减少内存占用\n",
    "#    - 适合处理大型数据集  # 对于大数据集尤其有用\n",
    "\n",
    "# 5. 预处理集成\n",
    "#    - 可以通过Dataset的__getitem__方法或DataLoader的collate_fn参数  # 提供数据预处理的方式\n",
    "#    - 在加载数据时自动应用变换和预处理  # 实现数据加载和预处理的无缝集成\n",
    "\n",
    "# 在我们的代码中：\n",
    "# - train_loader: 用于训练，启用了数据打乱以提高模型泛化能力  # 训练加载器配置了数据打乱\n",
    "# - val_loader和test_loader: 用于评估，不打乱数据以确保结果一致性  # 评估加载器保持数据顺序\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55040"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "64*860"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 搭建模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MNISTClassifier(\n",
      "  (fc1): Linear(in_features=784, out_features=300, bias=True)\n",
      "  (fc2): Linear(in_features=300, out_features=100, bias=True)\n",
      "  (fc3): Linear(in_features=100, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class MNISTClassifier(nn.Module):\n",
    "    # 定义初始化\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(28*28, 300)  # 第一隐藏层，输入维度为784(28*28)，输出维度为300\n",
    "        self.fc2 = nn.Linear(300, 100)    # 第二隐藏层，输入维度为300，输出维度为100\n",
    "        self.fc3 = nn.Linear(100, 10)     # 输出层，输入维度为100，输出维度为10（对应10个数字类别）\n",
    "\n",
    "    # 定义前向传播\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 28*28)            # 将输入的图像展平为向量，维度为784，-1表示自动计算batch_size\n",
    "                                         # 这行代码将输入的图像张量从形状[batch_size, 1, 28, 28]重塑为[batch_size, 784]\n",
    "                                         # view函数类似于numpy中的reshape，-1参数表示该维度的大小由其他维度自动推断\n",
    "                                         # 这是全连接层处理前的必要步骤，因为全连接层需要一维输入\n",
    "        x = F.relu(self.fc1(x))          # 第一隐藏层后应用ReLU激活函数\n",
    "\n",
    "        x = F.relu(self.fc2(x))          # 第二隐藏层后应用ReLU激活函数\n",
    "\n",
    "        x = self.fc3(x)                  # 输出层（不应用激活函数，因为后面会用交叉熵损失）\n",
    "        return x\n",
    "# 激活函数的作用\n",
    "# 1. 引入非线性\n",
    "#    - 没有激活函数，多层神经网络等同于单层线性模型  # 激活函数使网络能够学习复杂的非线性关系\n",
    "#    - 激活函数使网络能够学习和表示复杂的函数映射  # 增强网络的表达能力\n",
    "\n",
    "# 2. 常用激活函数\n",
    "#    - ReLU (Rectified Linear Unit): f(x) = max(0, x)  # 最常用的激活函数，计算高效，解决梯度消失问题\n",
    "#    - Sigmoid: f(x) = 1/(1+e^(-x))  # 将输出压缩到(0,1)区间，适合二分类问题\n",
    "#    - Tanh: f(x) = (e^x - e^(-x))/(e^x + e^(-x))  # 将输出压缩到(-1,1)区间，零中心化\n",
    "#    - Leaky ReLU: f(x) = max(αx, x), α是小正数  # 解决ReLU的\"死亡\"问题\n",
    "\n",
    "# 3. 在我们的模型中\n",
    "#    - 使用ReLU激活函数在隐藏层之后  # ReLU提供非线性变换并加速训练\n",
    "#    - 输出层不使用激活函数  # 原始logits将传递给损失函数(如交叉熵)\n",
    "\n",
    "# 4. 激活函数的影响\n",
    "#    - 影响模型的收敛速度  # 不同激活函数有不同的梯度特性\n",
    "#    - 影响模型的表达能力  # 决定网络能学习的函数类型\n",
    "#    - 影响模型的稳定性  # 某些激活函数可能导致梯度爆炸或消失\n",
    "\n",
    "\n",
    "# 创建模型实例\n",
    "model = MNISTClassifier()                # 实例化模型\n",
    "print(model)                             # 打印模型结构\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "批次图像形状: torch.Size([64, 1, 28, 28])\n",
      "批次标签形状: torch.Size([64])\n",
      "----------------------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# 从train_loader获取第一个批次的数据\n",
    "dataiter = iter(train_loader)  # 将训练数据加载器转换为迭代器对象\n",
    "images, labels = next(dataiter)  # 从迭代器中获取下一个批次的图像和标签数据\n",
    "\n",
    "# 查看批次数据的形状\n",
    "print(\"批次图像形状:\", images.shape)  # 打印图像批次的维度信息，通常为[batch_size, channels, height, width]\n",
    "print(\"批次标签形状:\", labels.shape)  # 打印标签批次的维度信息，通常为[batch_size]\n",
    "\n",
    "\n",
    "print('-'*100)  # 打印100个连字符作为分隔线，提高输出可读性\n",
    "# 进行前向传播\n",
    "with torch.no_grad():  # 不需要计算梯度，减少内存使用并加快计算速度\n",
    "    outputs = model(images)  # 将图像输入模型，获取模型的预测输出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([64, 1, 28, 28])\n",
      "torch.Size([64])\n",
      "torch.Size([1, 28, 28])\n",
      "9\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# 用第一张图片测试模型\n",
    "model = MNISTClassifier()\n",
    "dataiter = iter(train_loader)\n",
    "images, labels = next(dataiter)\n",
    "print(images.shape)\n",
    "print(labels.shape)\n",
    "\n",
    "print(images[0].shape)\n",
    "test_image=images[0].unsqueeze(0)   # 从批次中选择第一张图像(索引0)，并使用unsqueeze(0)添加一个批次维度，\n",
    "                                    # 将形状从[1,28,28]转换为[1,1,28,28]，使其可以作为单个样本输入到模型中\n",
    "with torch.no_grad():\n",
    "    output = model(test_image)\n",
    "_,predicted=torch.max(output,1)\n",
    "\n",
    "print(predicted.item())  # 打印预测的类别索引\n",
    "print(labels[0].item())  # 打印真实标签\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型总参数量: 266610\n",
      "--------------------------------------------------\n",
      "各层参数量明细:\n",
      "fc1.weight: 235200\n",
      "fc1.bias: 300\n",
      "fc2.weight: 30000\n",
      "fc2.bias: 100\n",
      "fc3.weight: 1000\n",
      "fc3.bias: 10\n"
     ]
    }
   ],
   "source": [
    "# 计算模型总参数量\n",
    "def count_parameters(model):\n",
    "    \"\"\"计算模型的总参数量\"\"\"\n",
    "    # 这行代码计算模型中所有可训练参数的总数量：\n",
    "    # - model.parameters() 获取模型中所有参数\n",
    "    # - if p.requires_grad 筛选出需要计算梯度的参数（即可训练参数）\n",
    "    # - p.numel() 获取每个参数张量中的元素数量\n",
    "    # - sum(...) 将所有参数的元素数量相加，得到总参数量\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)  # 计算所有需要梯度的参数数量总和\n",
    "\n",
    "total_params = count_parameters(model)  # 调用函数计算当前模型的参数量\n",
    "print(f\"模型总参数量: {total_params}\")  # 打印模型的总参数数量\n",
    "# 打印各层参数量\n",
    "print('-'*50)  # 打印分隔线，提高输出可读性\n",
    "print(\"各层参数量明细:\")  # 打印标题，表示下面将显示各层参数量\n",
    "for name, parameter in model.named_parameters():  # 遍历模型中所有命名参数\n",
    "    if parameter.requires_grad:  # 只统计需要梯度的参数\n",
    "        print(f\"{name}: {parameter.numel()}\")  # 打印每层的名称和参数数量\n",
    "\n",
    "# 可视化各层参数量\n",
    "layer_names = []  # 创建一个空列表用于存储层名称\n",
    "param_counts = []  # 创建一个空列表用于存储参数数量\n",
    "\n",
    "for name, parameter in model.named_parameters():  # 再次遍历模型参数\n",
    "    if parameter.requires_grad:  # 只处理需要梯度的参数\n",
    "        layer_names.append(name)  # 将层名称添加到列表\n",
    "        param_counts.append(parameter.numel())  # 将参数数量添加到列表\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n损失函数(Loss Function)的作用:\\n1. 衡量模型预测值与真实值之间的差距 - 量化模型预测的准确程度\\n2. 为模型提供优化方向 - 模型训练的目标是最小化损失函数\\n3. 将多维的预测问题转化为可优化的标量值\\n4. CrossEntropyLoss特别适合多分类问题，结合了softmax激活和负对数似然损失\\n\\n优化器(Optimizer)的作用:\\n1. 更新模型参数 - 根据损失函数的梯度调整权重和偏置\\n2. 控制学习过程 - 通过学习率等超参数控制参数更新的步长\\n3. 实现不同的优化策略 - SGD, Adam, RMSprop等算法各有特点\\n4. 帮助模型收敛到损失函数的局部最小值\\n5. SGD优化器中的momentum参数可以帮助模型跳出局部最小值，加速收敛\\n\\n两者协同工作:\\n损失函数计算当前参数下的误差，优化器根据误差梯度更新参数，共同完成模型的训练过程。\\n'"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 设置损失函数和优化器\n",
    "criterion = nn.CrossEntropyLoss()  # 创建交叉熵损失函数，适用于分类问题\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)  # 创建SGD优化器，设置学习率为0.01，动量为0.9\n",
    "# 解释损失函数和优化器的作用\n",
    "\"\"\"\n",
    "损失函数(Loss Function)的作用:\n",
    "1. 衡量模型预测值与真实值之间的差距 - 量化模型预测的准确程度\n",
    "2. 为模型提供优化方向 - 模型训练的目标是最小化损失函数\n",
    "3. 将多维的预测问题转化为可优化的标量值\n",
    "4. CrossEntropyLoss特别适合多分类问题，结合了softmax激活和负对数似然损失\n",
    "\n",
    "优化器(Optimizer)的作用:\n",
    "1. 更新模型参数 - 根据损失函数的梯度调整权重和偏置\n",
    "2. 控制学习过程 - 通过学习率等超参数控制参数更新的步长\n",
    "3. 实现不同的优化策略 - SGD, Adam, RMSprop等算法各有特点\n",
    "4. 帮助模型收敛到损失函数的局部最小值\n",
    "5. SGD优化器中的momentum参数可以帮助模型跳出局部最小值，加速收敛\n",
    "\n",
    "两者协同工作:\n",
    "损失函数计算当前参数下的误差，优化器根据误差梯度更新参数，共同完成模型的训练过程。\n",
    "\"\"\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义评估函数\n",
    "def evaluate_model(model, data_loader, device,criterion=None):\n",
    "    \"\"\"评估模型在给定数据集上的性能\"\"\"\n",
    "    model.eval()  # 将模型设置为评估模式\n",
    "    correct = 0  # 初始化正确预测的样本数\n",
    "    total = 0  # 初始化总样本数\n",
    "    running_loss = 0.0  # 初始化累计损失\n",
    "    \n",
    "    \n",
    "    with torch.no_grad():  # 在评估过程中不需要计算梯度\n",
    "        for images, labels in data_loader:  # 遍历数据加载器中的每一批数据\n",
    "            images, labels = images.to(device), labels.to(device)  # 将数据移动到指定设备(CPU/GPU)\n",
    "            outputs = model(images)  # 通过模型获取预测输出\n",
    "            _, predicted = torch.max(outputs.data, 1)  # 获取每个样本的预测类别\n",
    "            total += labels.size(0)  # 累加批次中的样本总数\n",
    "            correct += (predicted == labels).sum().item()  # 累加正确预测的样本数\n",
    "            if criterion is not None:\n",
    "                loss = criterion(outputs, labels)\n",
    "                running_loss += loss.item() * images.size(0)  # 累加当前批次的总损失：将每个样本的平均损失(loss.item())乘以样本数量(images.size(0))，得到批次总损失，并添加到running_loss中\n",
    "    accuracy = 100 * correct / total  # 计算准确率百分比\n",
    "    \n",
    "    if criterion is not None:\n",
    "        avg_loss = running_loss / total  # 计算平均损失率\n",
    "        return accuracy, avg_loss  # 返回准确率和损失率\n",
    "    return accuracy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练模型（函数）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, train_loader, val_loader, criterion, optimizer, device, num_epochs=5):\n",
    "    \"\"\"\n",
    "    训练模型函数\n",
    "    \n",
    "    参数:\n",
    "        model: 要训练的模型\n",
    "        train_loader: 训练数据加载器\n",
    "        val_loader: 验证数据加载器\n",
    "        criterion: 损失函数\n",
    "        optimizer: 优化器\n",
    "        device: 计算设备(CPU/GPU)\n",
    "        num_epochs: 训练轮数\n",
    "        \n",
    "    返回:\n",
    "        model: 训练好的模型\n",
    "        history: 训练历史数据，包含每轮的损失和准确率\n",
    "    \"\"\"\n",
    "    # 记录训练历史\n",
    "    history = {\n",
    "        'train_loss': [],\n",
    "        'train_acc': [],\n",
    "        'val_loss': [],\n",
    "        'val_acc': []\n",
    "    }\n",
    "    \n",
    "    # 训练循环\n",
    "    for epoch in range(num_epochs):\n",
    "        model.train()  # 设置为训练模式\n",
    "        running_loss = 0.0 #训练集损失\n",
    "        correct = 0 #训练集准确率\n",
    "        total = 0 #训练集总数\n",
    "        \n",
    "        # 训练一个epoch,把55000全部训练一遍\n",
    "        for i, (images, labels) in enumerate(train_loader):\n",
    "            images, labels = images.to(device), labels.to(device)\n",
    "            \n",
    "            # 梯度清零\n",
    "            optimizer.zero_grad()\n",
    "            \n",
    "            # 前向传播\n",
    "            outputs = model(images)\n",
    "            loss = criterion(outputs, labels)\n",
    "            \n",
    "            # 反向传播与优化\n",
    "            loss.backward() #反向传播，计算梯度\n",
    "            optimizer.step() #优化器更新参数\n",
    "            \n",
    "            # 统计训练集 损失和准确率\n",
    "            running_loss += loss.item()\n",
    "            _, predicted = torch.max(outputs.data, 1) #torch.max(outputs.data, 1)返回两个值，第一个是最大值，第二个是最大值的索引\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "            \n",
    "            # 每100个批次打印一次信息\n",
    "            if (i + 1) % 100 == 0:\n",
    "                print(f'轮次 [{epoch+1}/{num_epochs}], 批次 [{i+1}/{len(train_loader)}], 损失: {loss.item():.4f}', end='\\r')\n",
    "        \n",
    "        # 计算当前epoch的平均损失和准确率\n",
    "        epoch_train_loss = running_loss / len(train_loader)\n",
    "        epoch_train_acc = 100 * correct / total\n",
    "        \n",
    "        # 使用evaluate_model函数评估验证集\n",
    "        val_acc, val_loss = evaluate_model(model, val_loader, device, criterion)\n",
    "        \n",
    "        # 记录历史数据\n",
    "        history['train_loss'].append(epoch_train_loss)\n",
    "        history['train_acc'].append(epoch_train_acc)\n",
    "        history['val_loss'].append(val_loss)\n",
    "        history['val_acc'].append(val_acc)\n",
    "        \n",
    "        print(f'轮次 {epoch+1}/{num_epochs} 完成! 训练损失: {epoch_train_loss:.4f}, 训练准确率: {epoch_train_acc:.2f}%, 验证损失: {val_loss:.4f}, 验证准确率: {val_acc:.2f}%')\n",
    "    \n",
    "    \n",
    "    return model, history\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "使用设备: cpu\n",
      "轮次 1/50 完成! 训练损失: 0.7002, 训练准确率: 75.30%, 验证损失: 0.4864, 验证准确率: 82.54%\n",
      "轮次 2/50 完成! 训练损失: 0.4325, 训练准确率: 84.49%, 验证损失: 0.4212, 验证准确率: 84.88%\n",
      "轮次 3/50 完成! 训练损失: 0.3838, 训练准确率: 86.05%, 验证损失: 0.3987, 验证准确率: 85.40%\n",
      "轮次 4/50 完成! 训练损失: 0.3535, 训练准确率: 87.12%, 验证损失: 0.3672, 验证准确率: 86.82%\n",
      "轮次 5/50 完成! 训练损失: 0.3344, 训练准确率: 87.65%, 验证损失: 0.3632, 验证准确率: 86.64%\n",
      "轮次 6/50 完成! 训练损失: 0.3147, 训练准确率: 88.44%, 验证损失: 0.3647, 验证准确率: 86.70%\n",
      "轮次 7/50 完成! 训练损失: 0.3027, 训练准确率: 88.88%, 验证损失: 0.3298, 验证准确率: 87.90%\n",
      "轮次 8/50 完成! 训练损失: 0.2876, 训练准确率: 89.39%, 验证损失: 0.3438, 验证准确率: 87.34%\n",
      "轮次 9/50 完成! 训练损失: 0.2765, 训练准确率: 89.76%, 验证损失: 0.3178, 验证准确率: 88.38%\n",
      "轮次 10/50 完成! 训练损失: 0.2701, 训练准确率: 89.94%, 验证损失: 0.3534, 验证准确率: 86.48%\n",
      "轮次 11/50 完成! 训练损失: 0.2601, 训练准确率: 90.27%, 验证损失: 0.3401, 验证准确率: 87.24%\n",
      "轮次 12/50 完成! 训练损失: 0.2510, 训练准确率: 90.73%, 验证损失: 0.3219, 验证准确率: 88.36%\n",
      "轮次 13/50 完成! 训练损失: 0.2443, 训练准确率: 90.91%, 验证损失: 0.3074, 验证准确率: 88.64%\n",
      "轮次 14/50 完成! 训练损失: 0.2347, 训练准确率: 91.28%, 验证损失: 0.3057, 验证准确率: 89.14%\n",
      "轮次 15/50 完成! 训练损失: 0.2274, 训练准确率: 91.44%, 验证损失: 0.3355, 验证准确率: 87.56%\n",
      "轮次 16/50 完成! 训练损失: 0.2221, 训练准确率: 91.68%, 验证损失: 0.3092, 验证准确率: 88.76%\n",
      "轮次 17/50 完成! 训练损失: 0.2194, 训练准确率: 91.80%, 验证损失: 0.3191, 验证准确率: 88.72%\n",
      "轮次 18/50 完成! 训练损失: 0.2128, 训练准确率: 92.07%, 验证损失: 0.3103, 验证准确率: 88.82%\n",
      "轮次 19/50 完成! 训练损失: 0.2029, 训练准确率: 92.45%, 验证损失: 0.3164, 验证准确率: 88.56%\n",
      "轮次 20/50 完成! 训练损失: 0.2010, 训练准确率: 92.43%, 验证损失: 0.3223, 验证准确率: 88.84%\n",
      "轮次 21/50 完成! 训练损失: 0.1950, 训练准确率: 92.59%, 验证损失: 0.3085, 验证准确率: 89.02%\n",
      "轮次 22/50 完成! 训练损失: 0.1898, 训练准确率: 92.78%, 验证损失: 0.3325, 验证准确率: 88.08%\n",
      "轮次 23/50 完成! 训练损失: 0.1855, 训练准确率: 93.04%, 验证损失: 0.3125, 验证准确率: 88.88%\n",
      "轮次 24/50 完成! 训练损失: 0.1801, 训练准确率: 93.13%, 验证损失: 0.3200, 验证准确率: 88.94%\n",
      "轮次 25/50 完成! 训练损失: 0.1752, 训练准确率: 93.45%, 验证损失: 0.3158, 验证准确率: 88.60%\n",
      "轮次 26/50 完成! 训练损失: 0.1724, 训练准确率: 93.43%, 验证损失: 0.3088, 验证准确率: 88.88%\n",
      "轮次 27/50 完成! 训练损失: 0.1663, 训练准确率: 93.67%, 验证损失: 0.3135, 验证准确率: 89.16%\n",
      "轮次 28/50 完成! 训练损失: 0.1636, 训练准确率: 93.59%, 验证损失: 0.2999, 验证准确率: 89.86%\n",
      "轮次 29/50 完成! 训练损失: 0.1607, 训练准确率: 93.94%, 验证损失: 0.3582, 验证准确率: 88.82%\n",
      "轮次 30/50 完成! 训练损失: 0.1555, 训练准确率: 94.06%, 验证损失: 0.3340, 验证准确率: 88.94%\n",
      "轮次 31/50 完成! 训练损失: 0.1524, 训练准确率: 94.23%, 验证损失: 0.3420, 验证准确率: 88.34%\n",
      "轮次 32/50 完成! 训练损失: 0.1525, 训练准确率: 94.12%, 验证损失: 0.3287, 验证准确率: 89.04%\n",
      "轮次 33/50 完成! 训练损失: 0.1457, 训练准确率: 94.48%, 验证损失: 0.3299, 验证准确率: 89.18%\n",
      "轮次 34/50 完成! 训练损失: 0.1400, 训练准确率: 94.82%, 验证损失: 0.3353, 验证准确率: 88.86%\n",
      "轮次 35/50 完成! 训练损失: 0.1380, 训练准确率: 94.80%, 验证损失: 0.3369, 验证准确率: 89.40%\n",
      "轮次 36/50 完成! 训练损失: 0.1376, 训练准确率: 94.77%, 验证损失: 0.3747, 验证准确率: 87.90%\n",
      "轮次 37/50 完成! 训练损失: 0.1339, 训练准确率: 94.99%, 验证损失: 0.3433, 验证准确率: 88.60%\n",
      "轮次 38/50 完成! 训练损失: 0.1331, 训练准确率: 94.87%, 验证损失: 0.3524, 验证准确率: 89.10%\n",
      "轮次 39/50 完成! 训练损失: 0.1256, 训练准确率: 95.28%, 验证损失: 0.3442, 验证准确率: 89.64%\n",
      "轮次 40/50 完成! 训练损失: 0.1228, 训练准确率: 95.30%, 验证损失: 0.3794, 验证准确率: 88.76%\n",
      "轮次 41/50 完成! 训练损失: 0.1248, 训练准确率: 95.25%, 验证损失: 0.3664, 验证准确率: 88.96%\n",
      "轮次 42/50 完成! 训练损失: 0.1169, 训练准确率: 95.57%, 验证损失: 0.4020, 验证准确率: 88.56%\n",
      "轮次 43/50 完成! 训练损失: 0.1145, 训练准确率: 95.69%, 验证损失: 0.3845, 验证准确率: 88.54%\n",
      "轮次 44/50 完成! 训练损失: 0.1106, 训练准确率: 95.83%, 验证损失: 0.3566, 验证准确率: 89.20%\n",
      "轮次 45/50 完成! 训练损失: 0.1099, 训练准确率: 95.81%, 验证损失: 0.3802, 验证准确率: 88.54%\n",
      "轮次 46/50 完成! 训练损失: 0.1050, 训练准确率: 96.07%, 验证损失: 0.4002, 验证准确率: 89.20%\n",
      "轮次 47/50 完成! 训练损失: 0.1045, 训练准确率: 96.11%, 验证损失: 0.3839, 验证准确率: 88.98%\n",
      "轮次 48/50 完成! 训练损失: 0.1039, 训练准确率: 96.09%, 验证损失: 0.3787, 验证准确率: 88.90%\n",
      "轮次 49/50 完成! 训练损失: 0.0990, 训练准确率: 96.19%, 验证损失: 0.4081, 验证准确率: 88.76%\n",
      "轮次 50/50 完成! 训练损失: 0.0988, 训练准确率: 96.29%, 验证损失: 0.4268, 验证准确率: 88.20%\n"
     ]
    }
   ],
   "source": [
    "model = MNISTClassifier() #创建模型\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9) #创建SGD优化器，设置学习率为0.01，动量为0.9\n",
    "criterion = nn.CrossEntropyLoss() # 交叉熵损失函数\n",
    "\n",
    "# 将模型移动到可用设备上\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 检查是否有GPU可用\n",
    "model = model.to(device)  # 将模型移动到设备上\n",
    "print(f'使用设备: {device}')\n",
    "# 训练模型\n",
    "model,history = train_model(model, train_loader, val_loader, criterion, optimizer, device, num_epochs=50)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 设置中文字体，确保中文显示正常\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']  # 设置中文字体为黑体\n",
    "plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题\n",
    "\n",
    "# 创建一个2x1的子图布局\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))  # 创建一个1行2列的图表布局\n",
    "\n",
    "# 绘制损失曲线\n",
    "ax1.plot(history['train_loss'], label='训练损失')  # 绘制训练损失曲线，去除圆形标记\n",
    "ax1.plot(history['val_loss'], label='验证损失')  # 绘制验证损失曲线，去除方形标记\n",
    "ax1.set_title('损失曲线')  # 设置图表标题\n",
    "ax1.set_xlabel('轮次 (Epoch)')  # 设置x轴标签\n",
    "ax1.set_ylabel('损失值')  # 设置y轴标签\n",
    "ax1.legend()  # 显示图例\n",
    "ax1.grid(True)  # 显示网格线\n",
    "\n",
    "# 绘制准确率曲线\n",
    "ax2.plot(history['train_acc'], label='训练准确率')  # 绘制训练准确率曲线，去除圆形标记\n",
    "ax2.plot(history['val_acc'], label='验证准确率')  # 绘制验证准确率曲线，去除方形标记\n",
    "ax2.set_title('准确率曲线')  # 设置图表标题\n",
    "ax2.set_xlabel('轮次 (Epoch)')  # 设置x轴标签\n",
    "ax2.set_ylabel('准确率 (%)')  # 设置y轴标签\n",
    "ax2.legend()  # 显示图例\n",
    "ax2.grid(True)  # 显示网格线\n",
    "\n",
    "plt.tight_layout()  # 自动调整子图参数，使之填充整个图像区域\n",
    "plt.show()  # 显示图表\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
